function getStorage(key: string) {
	return uni.getStorageSync(`$${import.meta.env.VITE_CLIENTID}_${key}`);
}

function setStorage(options: any, value: string) {
	if (typeof options === 'string')
		return uni.setStorageSync(`$${import.meta.env.VITE_CLIENTID}_${options}`, value);
	if (options.key) options.key = `$${import.meta.env.VITE_CLIENTID}_${options.key}`;
	uni.setStorage(options);
}

function removeStorage(options: any) {
	if (typeof options === 'string')
		return uni.removeStorageSync(`$${import.meta.env.VITE_CLIENTID}_${options}`);
	if (options.key) options.key = `$${import.meta.env.VITE_CLIENTID}_${options.key}`;
	uni.removeStorage(options);
}

function queryStringToObject(str: any) {
	var obj: any = {}
	var splitStringArray = str.substring(str.indexOf("?") + 1).split('&');
	splitStringArray.forEach((item: any) => {
		if (item) {
			var kv = item.split('=');
			obj[kv[0]] = kv[1];
		}
	});
	return obj;
}

function objectToQueryString(obj: any) {
	var queryString = '?';
	for (let key in obj) {
		queryString += `${key}=${obj[key]}&`;
	}
	queryString = queryString.replace(/&$/, '');
	if (queryString === '?') {
		queryString = '';
	}
	return queryString;
}

function queryStringRemoveParams(url: string, names: any) {
	if (typeof(names) === 'string') {
		names = [names];
	}
	var obj = queryStringToObject(url);
	for (var i = 0; i < names.length; i++) {
		delete obj[names[i]];
	}
	return objectToQueryString(obj);
}

function toErrorPage(code: string, message: string) {
	uni.redirectTo({
		url: `/pages/error/error?code=${code}&message=${message}`
	});
}

function toLinkPage(link: string, title: string) {
	if (!link) return
	if(typeof(import.meta.env.VITE_CLIENTID) == "string") {
		if (!title) title = import.meta.env.VITE_CLIENTID
	}
	if (link.startsWith('/')) {
		uni.navigateTo({
			url: link
		});
	} else {
		uni.navigateTo({
			url: `/pages/webview/webview?link=${link}&title=${title}`
		});
	}
}

function navigateBack() {
	var pages = getCurrentPages();
	if (pages.length > 1) {
		uni.navigateBack({delta: 1});
	} else {
		uni.reLaunch({
			url: '/'
		});
	}
}

function toRFC3339(date: Date){
    let y = date.getFullYear()
    let m = date.getMonth()+1<10?'0'+(date.getMonth()+1):(date.getMonth()+1)
    let d = date.getDate()<10?'0'+date.getDate():date.getDate()
    let hh = date.getHours()<10?'0'+date.getHours():date.getHours();            
    let mm = date.getMinutes()<10?'0'+date.getMinutes():date.getMinutes()
    let ss = date.getSeconds()<10?'0'+date.getSeconds():date.getSeconds()
    var endDate = y +'-' + m + '-' + d + ' ' + hh + ':' + mm + ':' + ss
    endDate = endDate.replace(/\s+/g, 'T')+'+08:00'
    return endDate
}

function toTime(dateStr: string){
   var date = new Date(dateStr).toJSON();
   return new Date(+new Date(date)+8*3600*1000).toISOString().replace(/T/g,' ').replace(/\.[\d]{3}Z/,'');
}

// 日期格式化
function parseTime(time: any, pattern: string) {
    if (arguments.length === 0 || !time) {
        return null
    }
    const format = pattern || '{y}/{m}/{d} {h}:{i}'
    let date
    if (typeof time === 'object') {
        date = time
    } else {
        if ((typeof time === 'string') && (/^[0-9]+$/.test(time))) {
            time = parseInt(time)
        } else if (typeof time === 'string') {
            time = time.replace(new RegExp(/-/gm), '/');
        }
        if ((typeof time === 'number') && (time.toString().length === 10)) {
            time = time * 1000
        }
        date = new Date(time)
    }
    const formatObj: any = {
        y: date.getFullYear(),
        m: date.getMonth() + 1,
        d: date.getDate(),
        h: date.getHours(),
        i: date.getMinutes(),
        s: date.getSeconds(),
        a: date.getDay()
    }
    const time_str = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
        let value = formatObj[key]
            // Note: getDay() returns 0 on Sunday
        if (key === 'a') { return ['日', '一', '二', '三', '四', '五', '六'][value] }
        if (result.length > 0 && value < 10) {
            value = '0' + value
        }
        return value || 0
    })
    return time_str
}

/**
 * 构造树型结构数据
 * @param {*} data 数据源
 * @param {*} id id字段 默认 'id'
 * @param {*} parentId 父节点字段 默认 'parentId'
 * @param {*} children 孩子节点字段 默认 'children'
 * @param {*} rootId 根Id 默认 0
 */
function handleTree(data: any, id: string, parentId: string, children: string, rootId: number) {
  id = id || 'id'
	parentId = parentId || 'parentId'
	children = children || 'children'
	rootId = rootId || Math.min.apply(Math, data.map((item:any) => { return item[parentId] })) || 0
		//对源数据深度克隆
	const cloneData = JSON.parse(JSON.stringify(data))
		//循环所有项
	const treeData = cloneData.filter((father: any) => {
		let branchArr = cloneData.filter((child: any) => {
			//返回每一项的子级数组
			return father[id] == child[parentId]
		});
		branchArr.length > 0 ? father.children = branchArr : '';
		//返回第一层
		return father[parentId] == rootId;
	});
	return treeData != '' ? treeData : data;
}

// 回显数据字典
function selectDictLabel(datas: any,value: string,label='dictLabel',val='dictValue'){
    var actions: Array<string> = [];
    Object.keys(datas).some((key) => {
        if (datas[key][val] == ('' + value)) {
            actions.push(datas[key][label]);
            return true;
        }
    })
    return actions.join('');
}

// /*函数节流*/
// function throttle(fn: any, interval: number) {
// 	var enterTime = 0; //触发的时间
// 	var gapTime = interval || 1000; //间隔时间，如果interval不传，则默认300ms
// 	return () => {
// 		var context: any = this;
// 		var backTime: number = new Date().getTime(); //第一次函数return即触发的时间
// 		if (backTime - enterTime > gapTime) {
// 			fn.call(context, arguments);
// 			enterTime = backTime; //赋值给第一次触发的时间，这样就保存了第二次触发的时间
// 		}
// 	};
// }

// /*函数防抖*/
// function debounce(fn: any, interval: number) {
// 	var timer: any;
// 	var gapTime = interval || 1000; //间隔时间，如果interval不传，则默认1000ms
// 	return () => {
//     let that:any = this;
// 		clearTimeout(timer);
// 		var context = this;
// 		var args = arguments; //保存此处的arguments，因为setTimeout是全局的，arguments不是防抖函数需要的。
// 		timer = setTimeout(function() {
// 			fn.call(context, args);
// 		}, gapTime);
// 	};
// }


export default {
	getStorage,
	setStorage,
	removeStorage,
	queryStringToObject,
	objectToQueryString,
	queryStringRemoveParams,
	toErrorPage,
	toLinkPage,
	navigateBack,
	parseTime,
	handleTree,
	selectDictLabel,
	// throttle,
	// debounce,
	toRFC3339,
	toTime
}
